#ifndef MY_SERVER_HPP
#define MY_SERVER_HPP

#include "util.hpp"
#include "db.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "matcher.hpp"

//服务器模块
#define WWWROOT "./wwwroot/"
class gobang_server
{
private:
    wssrv_t _wssrv;
    std::string _web_root;//静态资源根目录 ./wwroot /register.html -> ./wwroot/register.html
    user_table _ut;
    online_manager _om;
    room_manager _rm;
    session_manager _sm;
    matcher _mm;


private:
    //静态资源请求的处理
    void file_handler(wssrv_t::connection_ptr& conn)
    {
        //1.获取到请求uri资源路径，了解客户端请求的页面文件名称
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();
        //2.组合出文件的实际路径 相对根目录 + uri
        std::string pathname = _web_root + uri;
        std::string body;
        //3.如果请求的是个目录，增加一个后缀 login.html
        if(pathname.back() == '/')
        {
            pathname += "login.html";
        }
        //4.读取文件内容
        bool ret = file_util::read(pathname, body);
        //文件不存在，读取文件失败，返回404
        if(ret == false)
        {
            body += "<html>";
            body += "<head>";
            body += "<meta charset='utf-8'>";
            body += "</head>";
            body += "<body>";
            body += "<h1>Not Found</h1>";
            body += "</body>";
            body += "</html>";
            conn->set_body(body);
            conn->set_status(websocketpp::http::status_code::not_found);
            return;
        }
        //5.设置响应正文
        conn->set_body(body);
        conn->set_status(websocketpp::http::status_code::ok);
    }

    //http回复处理
    void http_resp(wssrv_t::connection_ptr& conn, bool result, 
        websocketpp::http::status_code::value code, const std::string& reason)
    {
        Json::Value resp_json;
        resp_json["result"] = result;
        resp_json["reason"] = reason;
        std::string resp_body;
        json_util::serialize(resp_json, resp_body);
        conn->set_status(code);
        conn->set_body(resp_body);
        conn->append_header("content-type", "application/json");
        return;
    }

    //用户注册请求的处理
    void reg(wssrv_t::connection_ptr& conn)
    {
        //从WebSocket++ 连接对象中获取 HTTP 请求对象
        websocketpp::http::parser::request req = conn->get_request();
        //1.获取到请求正文
        std::string req_body = req.get_body();

        //2.对正文进行json序列化，得到用户名和密码
        Json::Value login_info;
        Json::Value resp_json;
        bool ret = json_util::unserialize(req_body, login_info);
        if(ret == false)
        {
            DLOG("反序列化注册信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }

        //3.进行数据库的用户新增操作
        std::string username = login_info["username"].asString();
        std::string password = login_info["password"].asString();
        if(username.empty() || password.empty())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        ret = _ut.insert(login_info);
        //如果成功，返回200
        //如果失败，返回400
        if(ret == false)
        {
            DLOG("向数据库插入数据失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名已经存在");
        }
        http_resp(conn, true, websocketpp::http::status_code::ok, "注册用户成功");
    }

    //用户登录请求的处理
    void login(wssrv_t::connection_ptr& conn)
    {
        //1.获取请求正文，并且进行json反序列化，得到用户名和密码
        std::string req_body = conn->get_request_body();
        //2.对正文进行json序列化，得到用户名和密码
        Json::Value login_info;
        bool ret = json_util::unserialize(req_body, login_info);
        if(ret == false)
        {
            DLOG("反序列化注册信息失败");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请求的正文格式错误");
        }
        //2.校验正文完整性，进行数据库的用户信息验证
          if(login_info["username"].isNull() || login_info["password"].isNull())
        {
            DLOG("用户名密码不完整");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "请输入用户名/密码");
        }
        //如果验证失败，返回400
        ret = _ut.login(login_info);
        if(ret == false)
        {
            DLOG("用户名密码错误");
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "用户名密码错误");
        }
        //3.如果验证成功，给客户端创建session
        //4.设置响应头部：Set-Cookie，将session-id通过cookie返回
        uint64_t uid = login_info["id"].asInt64();
        session_ptr ssp = _sm.create_session(uid, LOGIN);
        if(ssp.get() == nullptr)
        {
            DLOG("创建会话失败");
            return http_resp(conn, false, websocketpp::http::status_code::internal_server_error, "创建会话失败");
        }
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        std::string cookie_id = "SSID=" + std::to_string(ssp->ssid());
        conn->append_header("set-cookie", cookie_id);
        http_resp(conn, true, websocketpp::http::status_code::ok, "登录成功");
    }

    //获取cookie的key对应的值
    bool get_cookie_val(const std::string& cookie_str, const std::string& key, std::string& val)
    {
        //Cookie: SSID=XXX; pah=/;
        //1.以"; "作为分割符，对字符串进行分割，得到各个单个的cookie信息
        std::string sep = "; ";
        std::vector<std::string> cookie_arr;
        string_util::spilt(cookie_str, sep, cookie_arr);
        for(auto str : cookie_arr)
        {
            //2.对单个cookie字符串，以 = 为间隔进行分割，得到key和val
            std::vector<std::string> tmp_arr;
            string_util::spilt(str, "=", tmp_arr);
            if(tmp_arr.size() != 2)
            {
                continue;
            }
            if(tmp_arr[0] == key)
            {
                val = tmp_arr[1];
                return true;
            }
        }
        return false;
    }

    //用户信息获取功能请求的处理
    void info(wssrv_t::connection_ptr& conn)
    {
        //1.获取请求信息中的Cookie,从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("cookie");
        //如果没有cookie,返回错误。没有cookie信息，让客户端重新登录
        if(cookie_str.empty())
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到cookie信息,请重新登录");
        }

        //从cookie中取出ssid
        std::string ssid_str;
        int ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if(ret == false)
        {
            //cookie里面没有ssid,返回错误，没有ssid信息，让客户端重新登录
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到ssid信息,请重新登录");
        }

        //2.在session管理中查找对应的会话信息
        //没有找到session，则认为登录已经过期，需要重新登录
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if(ssp.get() == nullptr)
        {
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "登录过期,请重新登录");
        }
        
        //3.从数据库中取出用户信息，进行序列化发送给客户端
        uint64_t uid = ssp->get_user();
        Json::Value user_info;
        ret = _ut.select_by_id(uid, user_info);
        if(ret == false)
        {
            //数据库里面没有用户信息，让客户端重新登录
            return http_resp(conn, false, websocketpp::http::status_code::bad_request, "找不到用户信息,请重新登录");
        }

        std::string body;
        json_util::serialize(user_info, body);
        conn->set_body(body);
        conn->append_header("content-type", "application/json");
        conn->set_status(websocketpp::http::status_code::ok);
        
        //4.刷新session的过期时间
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    void http_callback(websocketpp::connection_hdl hdl)
    {
        //获取连接对象
        wssrv_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string method = req.get_method();
        std::string uri = req.get_uri();

        if(method == "POST" && uri == "/reg")
        {
            reg(conn);
        }
        else if(method == "POST" && uri == "/login")
        {
            login(conn);
        }
        else if(method == "GET" && uri == "/info")
        {
            info(conn);
        }
        else
        {
            file_handler(conn);
        }
    }

    //封装websocket回复
    void ws_resp(wssrv_t::connection_ptr conn, Json::Value& resp)
    {
        std::string body;
        json_util::serialize(resp, body);
        conn->send(body);
    }

    //封装通过cookie获取session
    session_ptr get_session_by_cookie(wssrv_t::connection_ptr conn)
    {
        Json::Value error_json;
        websocketpp::http::parser::request req = conn->get_request();
        //验证用户是否登录成功
        //1.获取请求信息中的Cookie,从Cookie中获取ssid
        std::string cookie_str = conn->get_request_header("cookie");
        //如果没有cookie,返回错误。没有cookie信息，让客户端重新登录
        if(cookie_str.empty())
        {
            error_json["optype"] = "hall_ready";
            error_json["reslut"] = false;
            error_json["reason"] = "找不到cookie信息,请重新登录";
            ws_resp(conn, error_json);
            return session_ptr();
        }

        //从cookie中取出ssid
        std::string ssid_str;
        int ret = get_cookie_val(cookie_str, "SSID", ssid_str);
        if(ret == false)
        {
            //cookie里面没有ssid,返回错误，没有ssid信息，让客户端重新登录
            error_json["optype"] = "hall_ready";
            error_json["reslut"] = false;
            error_json["reason"] = "找不到ssid信息,请重新登录";
            ws_resp(conn, error_json);
            return session_ptr();
        }

        //2.在session管理中查找对应的会话信息
        //没有找到session，则认为登录已经过期，需要重新登录
        session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
        if(ssp.get() == nullptr)
        {
            error_json["optype"] = "hall_ready";
            error_json["reslut"] = false;
            error_json["reason"] = "登录过期,请重新登录";
            ws_resp(conn, error_json);
            return session_ptr();
        }
        return ssp;
    }

    //游戏大厅长连接建立成功
    void wsopen_game_hall(wssrv_t::connection_ptr conn)
    {
        //1.登录验证 判断当前客户端是否已经成功登录
        //2.判断当前客户端是否重复登录
        Json::Value resp_json;
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
       
        //验证用户是否重复登录
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "hall_ready";
            resp_json["reslut"] = false;
            resp_json["reason"] = "用户重复登录";
            return ws_resp(conn, resp_json);
        }

        //3.将当前客户端以及连接加入到游戏大厅
        _om.enter_game_hall(ssp->get_user(), conn);

        //4.给客户端响应游戏大厅连接建立成功
        resp_json["optype"] = "hall_ready";
        resp_json["reslut"] = true;
        ws_resp(conn, resp_json);

        //5.记得将session设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
    }

    //游戏房间长连接建立成功
    void wsopen_game_room(wssrv_t::connection_ptr conn)
    {
        //1.获取当前客户端的session
        Json::Value resp_json;
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
        //2.当前用户是否已经在游戏房间或者游戏大厅中
        if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_room(ssp->get_user()))
        {
            resp_json["optype"] = "room_ready";
            resp_json["reslut"] = false;
            resp_json["reason"] = "用户重复登录";
            return ws_resp(conn, resp_json);
        }
        //3.判断当前用户是否已经创建好了房间
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if(rp.get() == nullptr)
        {
            resp_json["optype"] = "room_ready";
            resp_json["reslut"] = false;
            resp_json["reason"] = "没有找到该玩家的房间信息";
            return ws_resp(conn, resp_json);
        }
        //4.将当前用户添加到在线用户管理的游戏房间中
        _om.enter_game_room(ssp->get_user(), conn);
        //5.将session重新设置为永久存在
        _sm.set_session_expire_time(ssp->ssid(), SESSION_FOREVER);
        //6.回复房间准备完毕
        resp_json["optype"] = "room_ready";
        resp_json["reslut"] = true;
        resp_json["room_id"] = (Json::UInt64)rp->id();
        resp_json["uid"] = (Json::UInt64)ssp->get_user();
        resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
        resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
        return ws_resp(conn, resp_json);
    }

    void wsopen_callback(websocketpp::connection_hdl hdl)
    {
        //websocket长连接建立成功之后的处理函数
        wssrv_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        //建立了游戏大厅长连接
        if(uri == "/hall")
        {
            return wsopen_game_hall(conn);
        }
        //建立了游戏房间长连接
        else if(uri == "/room")
        {
            return wsopen_game_room(conn);
        }
    }

    void wsclose_game_hall(wssrv_t::connection_ptr conn)
    {
        //游戏大厅长连接断开的处理
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
        //1.将玩家从游戏大厅中移除
        _om.exit_game_hall(ssp->get_user());

        //2.将session恢复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
    }

    void wsclose_game_room(wssrv_t::connection_ptr conn)
    {
        //获取会话信息，识别客户端
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
        //1.将玩家从在线用户管理中移除
        _om.exit_game_room(ssp->get_user());
        //2.将session恢复生命周期的管理，设置定时销毁
        _sm.set_session_expire_time(ssp->ssid(), SESSION_TIMEOUT);
        //3.将玩家从游戏房间中移除，房间中所有用户退出了就会销毁房间
        _rm.remove_room_user(ssp->get_user());
    }

    void wsclose_callback(websocketpp::connection_hdl hdl)
    {
        wssrv_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        //建立了游戏大厅长连接
        if(uri == "/hall")
        {
            return wsclose_game_hall(conn);
        }
        //建立了游戏房间长连接
        else if(uri == "/room")
        {
            return wsclose_game_room(conn);
        }
        
    }

    void wsmsg_game_hall(wssrv_t::connection_ptr conn, wssrv_t::message_ptr msg)
    {
        Json::Value resp_json;
        //1.身份验证，当前客户端到底是哪个玩家
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
        //2.获取请求信息
        std::string body = msg->get_payload();
        Json::Value req_json;
        bool ret = json_util::unserialize(body, req_json);
        if(ret == false)
        {
            resp_json["result"] = false;
            resp_json["reason"] = "请求反序列化失败";
            return ws_resp(conn, resp_json);
        }

        //3.对于请求进行处理,然后给客户端响应
        //开始对战匹配：通过匹配模块，将用户添加到匹配队列中
        if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_start")
        {
            _mm.add(ssp->get_user());
            resp_json["optype"] = "match_start";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }
        //停止对战匹配：通过匹配模块，将用户从匹配队列中移除
        else if(!req_json["optype"].isNull() && req_json["optype"].asString() == "match_stop")
        {
            _mm.del(ssp->get_user());
            resp_json["optype"] = "match_stop";
            resp_json["result"] = true;
            return ws_resp(conn, resp_json);
        }

        resp_json["optype"] = "unknow";
        resp_json["reason"] = "请求类型未知";
        resp_json["result"] = false;
        return ws_resp(conn, resp_json);
    }

    void wsmsg_game_room(wssrv_t::connection_ptr conn, wssrv_t::message_ptr msg)
    {
        //1.获取客户端session,识别客户端身份
        session_ptr ssp = get_session_by_cookie(conn);
        if(ssp.get() == nullptr)
        {
            return;
        }
        //2.获取客户端房间信息
        Json::Value resp_json;
        std::string resp_body = msg->get_payload();
        room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
        if(rp.get() == nullptr)
        {
            resp_json["optype"] = "unknow";
            resp_json["reslut"] = false;
            resp_json["reason"] = "没有找到该玩家的房间信息";
            return ws_resp(conn, resp_json);
        }
        //3.对消息进行反序列化
        bool ret = json_util::unserialize(resp_body, resp_json);
        if(ret == false)
        {
            resp_json["optype"] = "unknow";
            resp_json["reason"] = "请求类型未知";
            resp_json["result"] = false;
            return ws_resp(conn, resp_json);
        }
        //4.通过房间模块进行消息请求的处理
        rp->handle_request(resp_json);
    }

    //webscoket长连接通信处理
    void wsmessage_callback(websocketpp::connection_hdl hdl, wssrv_t::message_ptr msg)
    {
        wssrv_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
        websocketpp::http::parser::request req = conn->get_request();
        std::string uri = req.get_uri();

        //建立了游戏大厅长连接
        if(uri == "/hall")
        {
            return wsmsg_game_hall(conn, msg);
        }
        //建立了游戏房间长连接
        else if(uri == "/room")
        {
            return wsmsg_game_room(conn, msg);
        }
    }
public:
    //进行成员初始化，以及服务器回调函数的设置
    gobang_server(const std::string& host,const std::string& user, 
        const std::string& passwd, 
        const std::string& dbname, unsigned int port = 3306, const std::string& web_root = WWWROOT)
        : _web_root(web_root), _ut(host, user, passwd, dbname, port),
          _rm(&_ut, &_om), _sm(&_wssrv), _mm(&_rm, &_ut, &_om)
    {
        //设置日志等级
        _wssrv.set_access_channels(websocketpp::log::alevel::none);
        //初始化asio调度器
        _wssrv.init_asio();
        //端口复用
        _wssrv.set_reuse_addr(true);
        //设置回调函数
        _wssrv.set_http_handler(std::bind(&gobang_server::http_callback, this, std::placeholders::_1));
        _wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback, this, std::placeholders::_1));
        _wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback, this, std::placeholders::_1));
        _wssrv.set_message_handler(std::bind(&gobang_server::wsmessage_callback, this, std::placeholders::_1, std::placeholders::_2));

    }

    //启动服务器
    void start(int port)
    {
        //设置监听端口
        _wssrv.listen(port);
        //开始获取新连接
        _wssrv.start_accept();
        //启动服务器
        _wssrv.run();
    }

};


#endif